package com.jason.campusinn.utils;/*
package com.jason.campusinn.utils;


import java.io.File;

import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.Bitmap.CompressFormat;
import android.graphics.Bitmap.Config;
import android.graphics.BitmapFactory;
import android.os.AsyncTask;
import android.widget.ImageView;

import com.nostra13.universalimageloader.cache.disc.DiscCacheAware;
import com.nostra13.universalimageloader.cache.disc.impl.LimitedAgeDiscCache;
import com.nostra13.universalimageloader.cache.disc.impl.UnlimitedDiscCache;
import com.nostra13.universalimageloader.cache.disc.naming.Md5FileNameGenerator;
import com.nostra13.universalimageloader.cache.memory.MemoryCacheAware;
import com.nostra13.universalimageloader.cache.memory.impl.LruMemoryCache;
import com.nostra13.universalimageloader.core.DefaultConfigurationFactory;
import com.nostra13.universalimageloader.core.DisplayImageOptions;
import com.nostra13.universalimageloader.core.ImageLoader;
import com.nostra13.universalimageloader.core.ImageLoaderConfiguration;
import com.nostra13.universalimageloader.core.assist.ImageScaleType;
import com.nostra13.universalimageloader.core.assist.ImageSize;
import com.nostra13.universalimageloader.core.assist.QueueProcessingType;
import com.nostra13.universalimageloader.core.decode.BaseImageDecoder;
import com.nostra13.universalimageloader.core.display.FadeInBitmapDisplayer;
import com.nostra13.universalimageloader.core.download.BaseImageDownloader;
import com.nostra13.universalimageloader.core.download.HttpClientImageDownloader;
import com.nostra13.universalimageloader.core.listener.ImageLoadingListener;
import com.nostra13.universalimageloader.core.listener.ImageLoadingProgressListener;
import com.nostra13.universalimageloader.utils.StorageUtils;
import com.yuandian.wanna.WannaApp;
import com.yuandian.wanna.R;
import com.yuandian.wanna.constants.Constants;

import org.apache.http.impl.client.DefaultHttpClient;

*/
/**
 * ImageLoader图片异步缓存
 *//*

public class ImageDownloader {

	private Context mContext;
	private static volatile ImageDownloader mDownloader;
	private ImageLoaderConfiguration mConfiguration;
	private ImageLoaderConfiguration.Builder mConfigurationBuilder;
	private ImageLoader mImageLoader;
	private DisplayImageOptions mOptions;
	private File cacheDir = StorageUtils.getOwnCacheDirectory(
            WannaApp.getInstance(), Constants.IMAGE_PATH);
	private DisplayImageOptions.Builder mOptionsBuilder;
	public ImageLoader getImageLoader() {
		return mImageLoader;
	}
	private ImageDownloader(Context context,
			ImageLoaderConfiguration configuration) {
		mContext = context;
		if (configuration == null) {
			createDefaultConfiguration();
		} else {
			mConfiguration = configuration;
		}
		if (mImageLoader == null) {
			initImageLoader(mConfiguration);
		}
		if (mOptions == null) {
			createDefaultOptions();
		}
	}

	public static synchronized ImageDownloader getInstance(Context context) {
		if (mDownloader == null) {
			mDownloader = new ImageDownloader(context, null);
		}
		return mDownloader;
	}

	public static synchronized ImageDownloader getInstance(
			Context context, ImageLoaderConfiguration configuration) {
		if (mDownloader == null) {
			mDownloader = new ImageDownloader(context, configuration);
		}
		return mDownloader;
	}

	*/
/**
	 * 获取默认的ImageLoaderConfiguration
	 * 
	 * @return
	 *//*

	public ImageLoaderConfiguration createDefaultConfiguration() {
		mConfigurationBuilder = new ImageLoaderConfiguration.Builder(mContext);
		mConfigurationBuilder
//                .memoryCacheExtraOptions(WannaApp.getInstance().mScreenWidth, WannaApp.getInstance().mScreenHeight)
				.discCacheExtraOptions(720, 1280, CompressFormat.PNG, 50, null)
				.threadPoolSize(2)
				.memoryCache(new LruMemoryCache(4 * 1024 * 1024))
				.discCacheSize(500 * 1024 * 1024).discCacheFileCount(150)
//				.discCache(new LimitedAgeDiscCache(cacheDir,5000))
                .discCache(new UnlimitedDiscCache(cacheDir))
                .discCacheFileNameGenerator(new Md5FileNameGenerator());
		mConfiguration = mConfigurationBuilder.build();
		return mConfiguration;

		*/
/**
		 * Configuration所有配置简介
		 *//*

		// 内存缓存的设置选项 (最大图片宽度,最大图片高度) 默认当前屏幕分辨率
		// .memoryCacheExtraOptions(480, 800)

		// 硬盘缓存的设置选项 (最大图片宽度,最大图片高度,压缩格式,压缩质量，处理器)
		// .discCacheExtraOptions(480, 800, CompressFormat.JPEG, 75, null)

		// 设置自定义加载和显示图片的线程池
		// .taskExecutor(DefaultConfigurationFactory.createExecutor(3,Thread.NORM_PRIORITY
		// - 1, QueueProcessingType.FIFO))

		// 设置自定义加载和显示内存缓存或者硬盘缓存图片的线程池
		// .taskExecutorForCachedImages(DefaultConfigurationFactory.createExecutor(3,Thread.NORM_PRIORITY
		// - 1, QueueProcessingType.FIFO))

		// 设置显示图片线程池大小，默认为3
		// 注:如果设置了taskExecutor或者taskExecutorForCachedImages 此设置无效
		// .threadPoolSize(3)

		// 设置图片加载线程的优先级,默认为Thread.NORM_PRIORITY-1
		// 注:如果设置了taskExecutor或者taskExecutorForCachedImages 此设置无效
		// .threadPriority(Thread.NORM_PRIORITY - 1)

		// 设置图片加载和显示队列处理的类型 默认为QueueProcessingType.FIFO
		// 注:如果设置了taskExecutor或者taskExecutorForCachedImages 此设置无效
		// .tasksProcessingOrder(QueueProcessingType.FIFO)

		// 设置拒绝缓存在内存中一个图片多个大小 默认为允许,(同一个图片URL)根据不同大小的imageview保存不同大小图片
		// .denyCacheImageMultipleSizesInMemory()

		// 设置内存缓存 默认为一个当前应用可用内存的1/8大小的LruMemoryCache
		// .memoryCache(new LruMemoryCache(2 * 1024 * 1024))

		// 设置内存缓存的最大大小 默认为一个当前应用可用内存的1/8
		// .memoryCacheSize(2 * 1024 * 1024)

		// 设置内存缓存最大大小占当前应用可用内存的百分比 默认为一个当前应用可用内存的1/8
		// .memoryCacheSizePercentage(13)

		// 设置硬盘缓存
        //FileCountLimitedDiscCache（可以设定缓存图片的个数，当超过设定值，删除掉最先加入到硬盘的文件）
        //LimitedAgeDiscCache（设定文件存活的最长时间，当超过这个值，就删除该文件）
        //TotalSizeLimitedDiscCache（设定缓存bitmap的最大值，当超过这个值，删除最先加入到硬盘的文件）
        //UnlimitedDiscCache（这个缓存类没有任何的限制）
		// 默认为StorageUtils.getCacheDirectory(getApplicationContext())
		// 即/mnt/sdcard/android/data/包名/cache/
		// .discCache(new
		// UnlimitedDiscCache(StorageUtils.getCacheDirectory(getApplicationContext())))

		// 设置硬盘缓存的最大大小
		// .discCacheSize(50 * 1024 * 1024)

		// 设置硬盘缓存的文件的最多个数
		// .discCacheFileCount(100)

		// 设置硬盘缓存文件名生成规范
		// 默认为new HashCodeFileNameGenerator()
		// .discCacheFileNameGenerator(new Md5FileNameGenerator())

		// 设置图片下载器
		// 默认为 DefaultConfigurationFactory.createBitmapDisplayer()
		// .imageDownloader(
		// new HttpClientImageDownloader(getApplicationContext(),
		// new DefaultHttpClient()))

		// 设置图片解码器
		// 默认为DefaultConfigurationFactory.createImageDecoder(false)
		// .imageDecoder(DefaultConfigurationFactory.createImageDecoder(false))

		// 设置默认的图片显示选项
		// 默认为DisplayImageOptions.createSimple()
		// .defaultDisplayImageOptions(DisplayImageOptions.createSimple())

		// 打印DebugLogs
		// .writeDebugLogs()

		// 建立
		// .build();
	}

	*/
/**
	 * 获取默认的DisplayImageOptions
	 * 
	 * @return
	 *//*

	public DisplayImageOptions createDefaultOptions() {
		BitmapFactory.Options decodingOptions = new BitmapFactory.Options();
		mOptionsBuilder = new DisplayImageOptions.Builder();
		mOptionsBuilder.cacheInMemory(false).cacheOnDisc(true)
				.imageScaleType(ImageScaleType.IN_SAMPLE_POWER_OF_2)
				.displayer(new FadeInBitmapDisplayer(300))
				.showImageForEmptyUri(R.drawable.ic_action_nothing)
				.bitmapConfig(Config.RGB_565)
				.decodingOptions(decodingOptions)
				.displayer(DefaultConfigurationFactory.createBitmapDisplayer());
		mOptions = mOptionsBuilder.build();
		return mOptions;

		*/
/**
		 * DisplayImageOptions所有配置简介
		 *//*


		// 设置图片加载时的默认图片
		// .showImageOnLoading(R.drawable.ic_chat_def_pic)

		// 设置图片加载失败的默认图片
		// .showImageOnFail(R.drawable.ic_chat_def_pic_failure)

		// 设置图片URI为空时默认图片
		// .showImageForEmptyUri(R.drawable.ic_chat_def_pic)

		// 设置是否将View在加载前复位
		// .resetViewBeforeLoading(false)

		// 设置延迟部分时间才开始加载
		// 默认为0
		// .delayBeforeLoading(100)

		// 设置添加到内存缓存
		// 默认为false
		// .cacheInMemory(true)

		// 设置添加到硬盘缓存
		// 默认为false
		// .cacheOnDisc(true)

		// 设置规模类型的解码图像
		// 默认为ImageScaleType.IN_SAMPLE_POWER_OF_2
		// .imageScaleType(ImageScaleType.IN_SAMPLE_POWER_OF_2)
        */
/*imageScaleType(ImageScaleType imageScaleType)
            imageScaleType:
                   EXACTLY :图像将完全按比例缩小的目标大小
                   EXACTLY_STRETCHED:图片会缩放到目标大小完全
                   IN_SAMPLE_INT:图像将被二次采样的整数倍
                   IN_SAMPLE_POWER_OF_2:图片将降低2倍，直到下一减少步骤，使图像更小的目标大小
                   NONE:图片不会调整*//*


		// 设置位图图像解码配置
		// 默认为Bitmap.Config.ARGB_8888
		// .bitmapConfig(Bitmap.Config.ARGB_8888)

		// 设置选项的图像解码
		// .decodingOptions(new Options())

		// 是否设置为圆角，弧度为多少
		// .displayer(new RoundedBitmapDisplayer(20))

		// 设置自定义显示器：设置图片显示动画的延迟时间
		// 默认为DefaultConfigurationFactory.createBitmapDisplayer()
		// .displayer(new FadeInBitmapDisplayer(300))

		// 设置自定义的handler
		// 默认为new Handler()
		// .handler(new Handler())

		// 建立
		// .build();
	}

	*/
/**
	 * 通过Configuration.Builder重置ImageLoader
	 * 
	 * @param builder
	 *//*

	public void initImageLoader(ImageLoaderConfiguration.Builder builder) {
		if (null == builder) {
			return;
		}
		mConfigurationBuilder = builder;
		initImageLoader(builder.build());
	}

	*/
/**
	 * 通过Configuration重置ImageLoader
	 * 
	 * @param configuration
	 *//*

	public void initImageLoader(ImageLoaderConfiguration configuration) {
		if (null == configuration) {
			return;
		}
		mConfiguration = configuration;
		mImageLoader = ImageLoader.getInstance();
		mImageLoader.init(configuration);
	}

	*/
/**获取文件缓存*//*

	public DiscCacheAware  getImageCahe(){
		return mImageLoader.getDiscCache();
	}
	
	*/
/**获取图片缓存*//*

	public MemoryCacheAware<String, Bitmap>  getMemoryCahe(){
		return mImageLoader.getMemoryCache();
	}
	
	public void displayImage(String uri, ImageView imageView) {
		mImageLoader.displayImage(uri, imageView, mOptions);
	}

	public void displayImage(String uri, ImageView imageView,
			DisplayImageOptions options) {
		mImageLoader.displayImage(uri, imageView, options);
	}

	public void displayImage(String uri, ImageView imageView,
			ImageLoadingListener listener) {
		mImageLoader.displayImage(uri, imageView, mOptions, listener);
	}
	
	public void displayImage(String uri, ImageView imageView,
			ImageLoadingListener listener,ImageLoadingProgressListener progressListener) {
		mImageLoader.displayImage(uri, imageView, mOptions, listener,progressListener);
	}

	public void displayImage(String uri, ImageView imageView,
			DisplayImageOptions options, ImageLoadingListener listener) {
		mImageLoader.displayImage(uri, imageView, options, listener);
	}
	
	public void displayImage(String uri, ImageView imageView,
			DisplayImageOptions options, ImageLoadingListener listener,ImageLoadingProgressListener progressListener) {
		mImageLoader.displayImage(uri, imageView, options, listener,progressListener);
	}

	public void loadImage(String uri, ImageLoadingListener listener) {
		mImageLoader.loadImage(uri, mOptions, listener);
	}
	
	public void loadImage(String uri, ImageLoadingListener listener,ImageLoadingProgressListener progressListener) {
		mImageLoader.loadImage(uri, null,mOptions, listener,progressListener);
	}

	public void loadImage(String uri, DisplayImageOptions options,
			ImageLoadingListener listener) {
		mImageLoader.loadImage(uri, options, listener);
	}
	
	public void loadImage(String uri, DisplayImageOptions options,
			ImageLoadingListener listener,ImageLoadingProgressListener progressListener) {
		mImageLoader.loadImage(uri, null,options, listener,progressListener);
	}

	public void loadImage(String uri, ImageSize minImageSize,
			ImageLoadingListener listener) {
		mImageLoader.loadImage(uri, minImageSize, mOptions, listener);
	}
	
	public void loadImage(String uri, ImageSize minImageSize,
			ImageLoadingListener listener,ImageLoadingProgressListener progressListener) {
		mImageLoader.loadImage(uri, minImageSize, mOptions, listener,progressListener);
	}

	public void loadImage(String uri, ImageSize targetImageSize,
			DisplayImageOptions options, ImageLoadingListener listener) {
		mImageLoader.loadImage(uri, targetImageSize, options, listener);
	}
	
	public void loadImage(String uri, ImageSize targetImageSize,
			DisplayImageOptions options, ImageLoadingListener listener,ImageLoadingProgressListener progressListener) {
		mImageLoader.loadImage(uri, targetImageSize, options, listener,progressListener);
	}

	public void onResume() {
		mImageLoader.resume();
	}

	public void onPause() {
		mImageLoader.pause();
	}

	public void onStop() {
		mImageLoader.stop();
	}

	public void onDestroy() {
		mImageLoader.destroy();
		mDownloader = null;
	}

	public void clearMemoryCache() {
		mImageLoader.clearMemoryCache();
	}

	public void clearDiscCache() {
		mImageLoader.clearDiscCache();
	}
}
*/
